Configuration d’application¶

2024 Conception logicielle

Chaque application fonctionne dans un environnement spécifique. Pour fonctionner correctement, il est nécessaire de configurer le comportement en fonction du contexte. La configuration est définie à différents niveaux, du plus général au plus spécifique :

Variable d’environnement ce sont des variables définies au niveau de l’environnement de l’application.
Arguments passés à un programme lors de son exécution.
Toggle peut contrôler l’activation d’une fonctionnalité dans le code source. Lorsque le drapeau est activé, la nouvelle fonctionnalité est active pour ces utilisateurs. Sinon, s’il est désactivé, elle est masquée et inaccessible.

Variable d’environnement¶

Liste toutes les variables d’environnement chargées dans le contexte courant

$ env
HOSTTYPE=x86_64
LANG=en_US.UTF-8
TERM=xterm-256color
XDG_RUNTIME_DIR=/mnt/wslg/runtime-dir
DISPLAY=:0
WAYLAND_DISPLAY=wayland-0
PULSE_SERVER=unix:/mnt/wslg/PulseServer
WSL2_GUI_APPS_ENABLED=1
WSLENV=WT_SESSION:WT_PROFILE_ID:

Charger les variables d’environnement à partir d’un fichier dotenv en Bash

export $(cat profile.env | xargs)

Arguments¶

Les arguments peuvent être passés via la ligne de commande. Exemple avec la commande find.

find /etc -type f -name *net*

Les arguments peuvent être écrits dans un fichier et utilisés via xargs.

$ cat filter_only_file_net.args
/etc
-type f
-name "*net*"

$ xargs -a filter_only_file_net.args find
/etc/netconfig
/etc/issue.net
/etc/systemd/networkd.conf
/etc/default/networking
/etc/java-17-openjdk/net.properties
/etc/networks
/etc/init.d/networking
/etc/perl/Net/libnet.cfg

Comment gérer les arguments :
- en Python avec argparse
- en C++ avec program_options

Exemple d’utilisation de program_options en C++

// g++ main.cpp -lboost_program_options
#include <boost/program_options.hpp>
#include <iostream>

int main(int argc, char **argv) {
    namespace ops = boost::program_options;

    ops::variables_map vm;
    ops::options_description parser("Usage: perf\n\n Options: ");
    double var = 0;

    parser.add_options()("help,h", "help message");
    parser.add_options()("var,v", ops::value<double>(&var), "var (default : \"0\")");

    try {
        ops::store(ops::parse_command_line(argc, argv, parser), vm);
        ops::notify(vm);
    } catch (const ops::error &ex) {
        throw std::runtime_error(std::string{} + __FILE__ + ":" +
                                 std::to_string(__LINE__) +
                                 " [-] error program_options " + ex.what());
    }

    if (vm.count("help")) {
        std::cout << parser << std::endl;
        exit(EXIT_SUCCESS);
    }

    std::cout<<var<<std::endl;
}

Toggle¶

Le toggle permet d’activer ou de désactiver une fonctionnalité exécutée par un logiciel. L’implémentation est très simple, c’est un booléen associé à une variable.

Basiquement, cela peut être vérifié comme suit

toggles.is_activited(name) return true otherwise false.

L’implémentation dépend de :

la performance de la vérification de l’activation de la variable
si la valeur de la variable change pendant l’exécution ou uniquement au chargement du programme
la portée des toggles : s’il existe un besoin global de singleton